Linux Cubed Series 8: LINUX Games/Linux Cubed Series 8 - LINUX Games.iso/games/x11/rpg/crossfir.92/crossfir/crossfire-0.92.5/doc/crosslib.doc

Text File | 1996-07-24 | 46KB | 1,570 lines

/*
 *   This file was automatically generated by version 1.6 of cextract.
 *   Manual editing not recommended.
 *
 *   Created: Fri Jul 23 09:17:43 1993
 */
#ifndef __CEXTRACT__
#if __STDC__

/*
 * Initialises the internal linked list of archetypes (read from file).
 * Then the global "empty_archetype" pointer is initialised.
 * Then the blocksview[] array is initialised.
 */
void init_archetypes ( void );

/*
 * Stores debug-information about how efficient the hashtable
 * used for archetypes has been in the static errmsg array.
 */
void arch_info ( object *op );

/*
 * Initialise the hashtable used by the archetypes.
 */
void clear_archetable ( void );

/*
 * An alternative way to init the hashtable which is slower, but _works_...
 */
void init_archetable ( void );

/*
 * Dumps an archetype to debug-level output.
 */
void dump_arch ( archetype *at );

/*
 * Dumps _all_ archetypes to debug-level output.
 * If you run crossfire with debug, and enter DM-mode, you can trigger
 * this with the O key.
 */
void dump_all_archetypes ( void );

/*
 * Allocates, initialises and returns the pointer to an archetype structure.
 */
archetype *get_archetype_struct ( void );

/*
 * Reads/parses the archetype-file, and copies into a linked list
 * of archetype-structures.
 */
void first_arch_pass ( FILE *fp );

/*
 * Reads the archetype file once more, and links all pointers between
 * archetypes.
 */
void second_arch_pass ( FILE *fp );

/*
 * First initialises the archtype hash-table (init_archetable()).
 * Reads and parses the archetype file (with the first and second-pass
 * functions).
 * Then initialises treasures by calling load_treasures().
 */
void load_archetypes ( void );

/*
 * Creates and returns a new object which is a copy of the given archetype.
 * This function returns NULL on failure.
 */
object *arch_to_object ( archetype *at );

/*
 * Creates an object.  This function is called by get_archetype()
 * if it fails to find the appropriate archetype.
 * Thus get_archetype() will be guaranteed to always return
 * an object, and never NULL.
 */
object *create_singularity ( char *name );

/*
 * Finds which archetype matches the given name, and returns a new
 * object containing a copy of the archetype.
 */
object *get_archetype ( char *name );

/*
 * Finds the first archetype matching the given type, and returns the
 * name of the object within the archetype.
 * TODO: Redo missile weapons to use direct archetype-pointers, since
 * that is the only thing left which uses this routine.
 * (This routine uses too much cpu)
 */
char *get_archename ( int t );

/*
 * Hash-function used by the arch-hashtable.
 */
unsigned long hasharch ( char *str );

/*
 * Finds, using the hashtable, which archetype matches the given name.
 * returns a pointer to the found archetype, otherwise NULL.
 */
archetype *find_archetype ( char *name );

/*
 * Adds an archetype to the hashtable.
 */
void add_arch ( archetype *at );

/*
 * Returns the first archetype using the given type.
 * Used in treasure-generation.
 */
archetype *type_to_archetype ( int type );

/*
 * Returns a new object copied from the first archetype matching
 * the given type.
 * Used in treasure-generation.
 */
object *clone_arch ( int type );

/*
 * member: make instance from class
 */
object *ObjectCreateArch ( archetype * at );

/*
 * Push the specified object.  This can affect other buttons/gates/handles
 * altars/pedestals/holes in the whole map.
 * Changed the routine to loop through _all_ objects.
 * Better hurry with that linked list...
 */
void push_button ( object *op );

/*
 * Updates everything connected with the button op.
 * After changing the state of a button, this function must be called
 * to make sure that all gates and other buttons connected to the
 * button reacts to the (eventual) change of state.
 */
void update_button ( object *op );

/*
 * Updates every button on the map (by calling update_button() for them).
 */
void update_buttons ( mapstruct *m );

void use_trigger ( object *op );

/* only one part objects */
void animate_turning ( object *op );

/*
 * check_altar checks if sacrifice was accepted and removes sacrificed
 * objects. If sacrifice was succeed return 1 else 0
 */
int check_altar ( object *altar );

/* 1 down and 0 up */
void trigger_move ( object *op, int state );

void check_trigger ( object *op );

void add_button_link ( object *button, mapstruct *map, int connected );

/*
 * Remove the object from the linked lists of buttons in the map.
 * This is only needed by editors.
 */
void remove_button_link ( object *op );

/*
 * Return the first objectlink in the objects linked to this one
 */
objectlink *get_button_links ( object *button );

/*
 * Made as a separate function to increase efficiency
 */
int get_button_value ( object *button );

/*
 * nex_exp() is an alternative way to calculate experience based
 * on the ability of a monster.
 * It's far from perfect, and doesn't consider everything which
 * can be considered, thus it's only used in debugging.
 */
int new_exp ( object *ob );

/*
 * Returns true if the monster specified has any innate abilities.
 */
int has_ability ( object *ob );

/*
 * Add a new friendly object to the linked list of friendly objects.
 * No checking to see if the object is already in the linked list is done.
 */
void add_friendly_object ( object *op );

/*
 * Removes the specified object from the linked list of friendly objects.
 */
void remove_friendly_object ( object *op );

/*
 * Dumps all friendly objects.  Invoked in DM-mode with the G key.
 */
void dump_friendly_objects ( void );

/*
 * Initialise all function-pointers to dummy-functions which will
 * do nothing and return nothing (of value at least).
 * Very healthy to do this when using the library, since
 * function pointers are being called throughout the library, without
 * being checked first.
 * init_library() calls this function.
 */
void init_function_pointers ( void );

/*
 * Specifies which function to call when there is an emergency save.
 */
void set_emergency_save ( void (*addr)(int) );

/*
 * Specifies which function to call to clean temporary files.
 */
void set_clean_tmp_files ( void (*addr)() );

/*
 * Specifies which function to call to fix auto-apply (objects which
 * applies themselves when their map is loaded).
 */
void set_fix_auto_apply ( void (*addr)(mapstruct *) );

/*
 * Specifies which function to call to remove an object in the
 * linked list of friendly objects.
 */
void set_remove_friendly_object ( void (*addr)(object *) );

/*
 * Specify which function to call to do some work in active
 * maps.  That function might get called if there are several players,
 * and one player is using too much cpu to either load a map, or to
 * load pixmaps.
 */
void set_process_active_maps ( void (*addr)(void) );

/*
 * Specify which function to call to recoordinate all buttons.
 */
void set_update_buttons ( void (*addr)(mapstruct *) );

/*
 * Specify which function to call to draw text to the window
 * of a player.
 */
void set_draw_info ( void (*addr)(object *, const char *) );

/*
 * Specify which function to call to update the text in the
 * stat-window of a player.
 */
void set_draw_stats ( void (*addr)(object *) );

/*
 * Specify which function to call to update the graphics in the
 * inventory-window of a player.
 */
void set_draw_inventory_faces ( void (*addr)(object *) );

/*
 * Specify which function to call to update the graphics
 * in the look-window of a player.
 */
void set_draw_look_faces ( void (*addr)(object *) );

/*
 * Specify which function to call to update the content
 * in the inventory-window of a player.
 */
void set_draw_inventory ( void (*addr)(object *) );

/*
 * Specify which function to call to update the content
 * of the look-window of a player.
 */
void set_draw_look ( void (*addr)(object *) );

/*
 * Specify which function to call to apply an object.
 */
void set_apply ( int (*addr)(object *, object *) );

/*
 * Specify which function to call to draw on the graphic-window
 * of a player.
 */
void set_draw ( void (*addr)(object *) );

/*
 * Specify which function to call to check if a monster can
 * apply an object.
 */
void set_monster_check_apply ( object *(*addr)(object *, object *) );

/*
 * Specify which functino to call to initialise the blocksview[] array.
 */
void set_init_blocksview_players ( void (*addr)(void) );

void set_info_map ( void (*addr)(mapstruct *, char *) );

/*
 * fatal() is meant to be called whenever a fatal signal is intercepted.
 * It will call the emergency_save and the clean_tmp_files functions.
 */
void fatal ( int err );

/*
 * Dump to standard out the abilities of all monsters.
 */
void dump_abilities ( void );

/*
 * As dump_abilities(), but with an alternative way of output.
 */
void print_monsters ( void );

/*
 * Writes <num> ones and zeros to the given string based on the
 * <bits> variable.
 */
void bitstostring ( long bits, int num, char *str );

/*
 * It is vital that init_library() is called by any functions
 * using this library.
 * If you want to lessen the size of the program using the library,
 * you can replase the call to init_library() with init_globals(),
 * init_function_pointers() and init_defaults().
 * (This is done in the client)
 */
void init_library ( void );

/*
 * Initialises all global variables.
 * Might use environment-variables as default for some of them.
 */
void init_globals ( void );

/*
 * Sets up and initialises the linked list of free and used objects.
 * Allocates a certain chunk of objects and puts them on the free list.
 * Called by init_library();
 */
void init_objects ( void );

/*
 * Initialises global variables which can be changed by options.
 * Called by init_library().
 */
void init_defaults ( void );

/*
 * query_weight(object) returns a character pointer to a static buffer
 * containing the text-representation of the weight of the given object.
 * The buffer will be overwritten by the next call to query_weight().
 */
char *query_weight ( object *op );

/*
 * get_number(integer) returns the text-representation of the given number
 * in a static buffer.  The buffer might be overwritten at the next
 * call to get_number().
 * It is currently only used by the query_name() function.
 */
char *get_number ( int i );

/*
 * query_name(object) returns a character pointer pointing to a static
 * buffer which contains a verbose textual representation of the name
 * of the given object.  The buffer will be overwritten at the next
 * call to query_name().
 */
char *query_name ( object *op );

/*
 * Returns a pointer to a static buffer which contains a
 * description of the given object.
 * If it is a monster, lots of information about its abilities
 * will be returned.
 * If it is an item, lots of information about which abilities
 * will be gained about its user will be returned.
 * If it is a player, it writes out the current abilities
 * of the player, which is usually gained by the items applied.
 */
char *describe_item ( object *op );

int always_magical ( object *op );

int need_identify ( object *op );

/*
 * Supposed to fix face-values as well here, but later.
 */
void identify ( object *op );

/*
 * Allocates a new objectlink structure, initialises it, and returns
 * a pointer to it.
 */
objectlink *get_objectlink ( void );

/*
 * Allocates a new oblinkpt structure, initialises it, and returns
 * a pointer to it.
 */
oblinkpt *get_objectlinkpt ( void );

/*
 * Recursively frees all objectlinks
 */
void free_objectlink ( objectlink *ol );

/*
 * Recursively frees all linked list of objectlink pointers
 */
void free_objectlinkpt ( oblinkpt *obp );

/*
 * sets Str/Dex/con/Wis/Cha/Int in stats to value, depending on
 * what attr is (STR to INT).
 */
void set_attr_value ( living *stats, int attr, signed char value );

/*
 * Like set_attr_value(), but instead the value (which can be negative)
 * is added to the specified stat.
 */
void change_attr_value ( living *stats, int attr, signed char value );

/*
 * returns the specified stat.  See also set_attr_value().
 */
signed char get_attr_value ( living *stats, int attr );

/*
 * Ensures that all stats (str/dex/con/wis/cha/int) are within the stat limit.
 */
void check_stat_bounds ( object *op );

/*
 * Adds abilities to the first object based on what the second object
 * gives to appliers.  If the second object does not have the APPLIED
 * flag set, it is assumed that it is being unapplied, and any abilities
 * it gives are subtracted from the first object.
 * (This is of course a problem now, since several objects may give
 * the same abilities, thus change_abil() is used mostly to display
 * messages, while fix_player() is called afterwards.)
 * Also writes a more or less informative message to the first object
 * about what abilities were gained/lost.
 */
int change_abil ( object *op, object *tmp );

/*
 * Stat draining by Vick 930307
 * (Feeling evil, I made it work as well now.  -Frank 8)
 */
void drain_stat ( object *op );

void drain_specific_stat ( object *op, int deplete_stats );

/*
 * A value of 0 indicates timeout, otherwise change the luck of the object.
 * via an applied bad_luck object.
 */
void change_luck ( object *op, int value );

/*
 * Subtracts stat-bonuses given by the class which the player has chosen.
 */
void remove_statbonus ( object *op );

/*
 * Adds stat-bonuses given by the class which the player has chosen.
 */
void add_statbonus ( object *op );

/*
 * Updates all abilities given by applied objects in the inventory
 * of the given object.  Note: This function works for both monsters
 * and players; the "player" in the name is purely an archaic inheritance.
 */
void fix_player ( object *op );

/*
 * Returnes true if the given player is a legal class.
 * The function to add and remove class-bonuses to the stats doesn't
 * check if the stat becomes negative, thus this function
 * merely checks that all stats are 1 or more, and returns
 * false otherwise.
 */
int allowed_class ( object *op );

/*
 * Returns how much experience is needed for a player to become
 * the given level.
 */
int level_exp ( int level );

/*
 * Adds (or subtracts) experience to a living object.  If it is a player,
 * checks for level-gain/loss is done.
 * The routines for gaining/losing levels is also within this function.
 */
void add_exp ( object *op, int exp );

/*
 * Initialises the array of variable-names.  Needed before any
 * objects can be loaded.  Called by init_library().
 */
void init_vars ( void );

/*
 * Searches through all possible variables to find any that matches
 * the given string.  An index to the variable_const[] array is returned,
 * or -1 on failure.
 */
int get_variable ( char *name );

/*
 * Returns a pointer to a static string which contains all variables
 * which are different in the two given objects.
 */
char *get_ob_diff ( object *op, object *op2 );

/*
 * Dumps all variables in an object to a file.
 * If big 0 of flag is set, do a raw save without any checks.
 * If bit 1 of flag is set, don't remove the object after save.
 */
void save_object ( FILE *fp, object *op, int flag );

/*
 * Returns true if the given color exists in the internal list
 * of legal colors.
 */
char find_color ( char *name );

/*
 * set_variable() expects buf to be a line with two arguments, the first
 * being a variable and the second being the value (which can be anything from
 * an integer to a string).
 * The object given will have the given variable modified.
 *
 * -1 will be returned if there is no such variable
 * 0 will be returned if the variable is to be ignored
 * 1 will be returned if the variable was "anim"
 * 2 will be returned if the variable was "end"
 * 3 will be returned if the variable was "Inventory"
 * 4 will be returned if the variable was "More"
 * 5 will be returned if the variable was "msg"
 * 6 will be returned if the variable was "endmsg"
 * otherwise 0 will be returned
 */
int set_variable ( object *op, char *buf );

/*
 * Loads an object from the given file-pointer.
 * Variables will be read and parsed and patched into the object
 * until the string "end" is reached, or the end of the file.
 * If EOF is reached, it returnes false, otherwise true.
 */
int load_object ( FILE *fp, object *op );

/*
 * Logs a message to stderr, or to file, and/or even to socket.
 * Or discards the message if it is of no importanse, and none have
 * asked to hear messages of that logLevel.
 * logLevels can be logError (always printed), llevDebug, and llevMonster.
 */
void LOG ( LogLevel logLevel, char *format, ... );

/*
 * Used to initialise the array used by the LOS routines.
 */
void set_block ( int x, int y, int bx, int by );

/*
 * initialises the array used by the LOS routines.
 */
void init_block ( void );

/*
 * Used to initialise the array used by the LOS routines.
 */
void set_wall ( object *op, int x, int y );

/*
 * Used to initialise the array used by the LOS routines.
 */
void check_wall ( object *op, int x, int y );

/*
 * Clears/initialises the los-array associated to the player
 * controlling the object.
 */
void clear_los ( object *op );

/*
 * expand_sight goes through the array of what the given player is
 * able to see, and expands the visible area a bit, so the player will,
 * to a certain degree, be able to see into corners.
 * This is somewhat suboptimal, would be better to improve the formula.
 * There are two versions of this function, based on wheter or not
 * CD_LINE_OF_SIGHT is defined.  If it is defined, the function
 * becomes a bit more time-consuming, but covers a few more "corners"...
 */
void expand_sight ( object *op );

/*
 * update_los() recalculates the array which specifies what is
 * visible for the given player-object.
 */
void update_los ( object *op );

/*
 * This function makes sure that update_los() will be called for all
 * players on the given map within the next frame.
 * It is triggered by removal or inserting of objects which blocks
 * the sight in the map.
 */
void update_all_los ( mapstruct *map );

/*
 * Debug-routine which dumps the array which specifies the visible
 * area of a player.  Triggered by the z key in DM mode.
 */
void print_los ( object *op );

/*
 * check_face_range() is used from init_blocksview() to avoid
 * crashing the game due to buggy data in the archetype file.
 * Must maintain some sanity in this madness... 8)
 */
int check_face_range ( Fontindex face, char *name );

/*
 * init_blocksview() fills an array (blocksview[]) with information
 * about which characters/pixmaps are blocking views.
 * This doesn't handle all cases (dropping a coin on top of a mountain),
 * but it's much faster than checking all the objects for BLOCKS_VIEW().
 */
void init_blocksview ( void );

/*
 * make_sure_seen: The object is supposed to be visible through walls, thus
 * check if any players are nearby, and edit their LOS array.
 */
void make_sure_seen ( object *op );

/*
 * make_sure_not_seen: The object which is supposed to be visible through
 * walls has just been removed from the map, so update the los of any
 * players within its range
 */
void make_sure_not_seen ( object *op );

/*
 * returns a char-pointer to a static array, in which a representation
 * of the decimal number given will be stored.
 */
char *ltostr10 ( signed long n );

/*
 * A fast routine which appends the name and decimal number specified
 * to the given buffer.
 * Could be faster, though, if the strcat()s at the end could be changed
 * into alternate strcat which returned a pointer to the _end_, not the
 * start!
 */
void save_long ( char *buf, char *name, long n );

/*
 * Returns the mapstruct which has a name matching the given argument.
 */
mapstruct *has_been_loaded ( char *name );

/*
 * This makes a path absolute outside the world of Crossfire.
 * In other words, it prepends LIBDIR/MAPDIR/ to the given path
 * and returns the pointer to a static array containing the result.
 */
char *create_pathname ( char *name );

/*
 * This program checks if a file with the given path exists.
 * -1 is returned if it failes, otherwise the mode of the file
 * is returned.
 */
int check_path ( char *name );

/*
 * Prints out debug-information about a map.
 */
void dump_map ( mapstruct *m );

/*
 * Prints otu debug-information about all maps.
 */
void dump_all_maps ( void );

/*
 * Returns true if a wall is present in a given location.
 */
int wall ( mapstruct *m, int x, int y );

/*
 * Returns true if it's impossible to see through the given coordinate
 * in the given map.
 */
int blocks_view ( mapstruct *m, int x, int y );

/*
 * Returns true if the given coordinate in the given map blocks magic.
 */
int blocks_magic ( mapstruct *m, int x, int y );

/*
 * Returns true if the given coordinate in the given map blocks passage.
 */
int blocked ( mapstruct *m, int x, int y );

/*
 * Returns true if the given coordinate in the map where the given object
 * is, blocks the given object (which may be multi-part)
 */
int blocked_link ( object *ob, int x, int y );

/*
 * Eneq(@csd.uu.se): This is a new version of blocked, this one handles objects
 * that can be passed through by monsters with the CAN_PASS_THRU defined.
 */
int blocked_two ( object *op, int x, int y );

/*
 * Returns true if the given archetype can't fit in the given spot.
 */
int arch_blocked ( archetype *at, mapstruct *m, int x, int y );

/*
 * Returns true if the given archetype can't fit into the map at the
 * given spot (some part of it is outside the map-boundaries).
 */
int arch_out_of_map ( archetype *at, mapstruct *m, int x, int y );

/*
 * Goes through all objects in the given map, and does a sanity-check
 * on all pointers.
 */
void refresh_map ( mapstruct *m );

/*
 * open_and_uncompress() first searches for the original filename.
 * if it exist, then it opens it and returns the file-pointer.
 * if not, it does two things depending on the flag.  If the flag
 * is set, it tries to create the original file by uncompressing a .Z file.
 * If the flag is not set, it creates a temporarily file and uncompresses
 * the .Z file into that file.  The temporary file will be deleted in
 * close_and_delete().
 * (Note, the COMPRESS_SUFFIX is used instead of ".Z", thus it can easily
 * be changed in the config file.)
 */
FILE *open_and_uncompress ( char *name, int flag, int *compressed );

/*
 * See open_and_uncompress().
 */
void close_and_delete ( FILE *fp );

/*
 * Loads (ands parses) the objects into a given map from the specified
 * file pointer.
 * If block is true, the game will be blocked until all objects have
 * been loaded (this is needed to avoid certain critical regions).
 */
void load_objects ( mapstruct *m, FILE *fp, int block );

void save_objects ( mapstruct *m, FILE *fp );

/*
 * Opens the file "filename" and reads information about the map
 * from the given file, and stores it in a newly allocated
 * mapstruct.  A pointer to this structure is returned, or NULL on failure.
 * If block is true, it will block the game while reading the objects.
 */
mapstruct *load_original_map ( char *filename, int block );

/*
 * Loads a map, which has been loaded earlier, from file.
 */
void load_temporary_map ( mapstruct *m );

void queue_push ( object* m_ob );

object *queue_pop ( void );

/*
 * Saves a map to file.  If flag is set, it is saved into the same
 * file it was (originally) loaded from.  Otherwise a temporary
 * filename will be genarated, and the file will be stored there.
 * The temporary filename will be stored in the mapstructure.
 */
void new_save_map ( mapstruct *m, int flag );

/*
 * If any directories in the given path doesn't exist, they are created.
 */
void make_path_to_file ( char *filename );

/*
 * Used to fix an ancient bug in old maps.
 * Will soon be obsolete.
 */
void check_background ( mapstruct *m, int x, int y );

/*
 * Clears the arrays containing object-pointers and outlook of a map.
 */
void clear_map ( mapstruct *m );

/*
 * This function relinks all _pointers_ to the objects from
 * one map to another.
 * Note: You can _not_ free the objects in the original map
 * after this function has been called.
 * (What happened to this function? It no longer copies the pointers! -Frank)
 */
void copy_map ( mapstruct *m1, mapstruct *m2 );

/*
 * This function, like copy_map(), relinks all _pointers_ from
 * one map to the other map.
 */
void relink_objs_offset ( mapstruct *m1, mapstruct *m2, int dx, int dy );

/*
 * Remove and free all objects in the inventory of the given object.
 */
void clean_object ( object *op );

/*
 * Remove and free all objects in the given map.
 */
void free_all_objects ( mapstruct *m );

/*
 * This function moves all objects from one map to another.
 *
 * move_all_objects(): Only used from the editor(s?)
 * Yes. -Frank
 */
void move_all_objects ( mapstruct *m1, mapstruct *m2 );

/*
 * function: vanish mapstruct
 * m       : pointer to mapstruct, if NULL no action
 */
void delete_map ( mapstruct *m );

/*
 * Frees everything allocated by the given mapstructure.
 */
void free_map ( mapstruct *m, int flag );

/*
 * If there is a global message in the map where the given object is,
 * display the message to the object.
 */
void draw_map_message ( object *op );

/*
 * Allocates, initialises, and returns a pointer to a mapstruct.
 */
mapstruct *get_linked_map ( char *path );

/*
 * Allocates the arrays contained in a mapstruct.
 */
void allocate_map ( mapstruct *m );

/*
 * Creates an empty map of the given size, and returns a pointer to it.
 */
mapstruct *get_empty_map ( int sizex, int sizey );

/*
 * An obsolete function, replaced by ready_map_name().
 */
mapstruct *ready_map ( int level, int flag );

/*
 * Makes sure the given map is loaded and swapped in.
 * Returns a pointer to the given map.
 */
mapstruct *ready_map_name ( char *name, int flush );

void no_maps_file ( char *filename );

void find_first_level ( char *path );

char *find_map_name ( int level );

void update_map_name ( int level, char *name );

void set_map_reset_time ( mapstruct *map );

/*
 * This routine is supposed to find out which level the players should have
 * before visiting this map.  It is used to calculate which bonuses to put
 * on magic items.
 */
int calculate_difficulty ( mapstruct *m );

void clean_tmp_map ( mapstruct *m );

object * MapGetObjectZ ( mapstruct * emap, int x, int y, int z );

/*
 * member: copy by translate objects from source to target
 * target: -map
 * source: -map
 * dx    : positive translate to right
 * dy    : positive translate to down
 */
void MapMoveScroll ( mapstruct *target, mapstruct *source, int dx, int dy );

object * MapGetRealObject ( mapstruct * emap, int x, int y, int z );

int MapInsertObjectZ ( mapstruct *emap, object *o, int x, int y, int z );

int MapObjectOut ( mapstruct *target, object *obj, int x, int y );

/*
 * Eneq(@csd.uu.se): Since we can have items buried in a character we need
 * a better check
 */
object *is_player_inv ( object *op );

/*
 * Used by Crossedit?
 * The result of the dump is stored in the static global errmsg array.
 */
void dump_object2 ( object *op );

/*
 * Dumps an object.  Returns output in the static global errmsg array.
 */
void dump_object ( object *op );

/*
 * This is really verbose...Can be triggered by the P key while in DM mode.
 * All objects are dumped to stderr (or alternate logfile, if in server-mode)
 */
void dump_all_objects ( void );

/*
 * animate_object(object) updates the face-variable of an object.
 * If the object is the head of a multi-object, all objects are animated.
 * If the object has the IS_TURNING() flag, that is taken into consideration.
 */
void animate_object ( object *op );

/*
 * get_nearest_part(multi-object, object 2) returns the part of the
 * multi-object 1 which is closest to the second object.
 * If it's not a multi-object, it is returned.
 */
object *get_nearest_part ( object *op, object *pl );

/*
 * Returns the object which has the count-variable equal to the argument.
 */
object *find_object ( int i );

/*
 * Returns the first object which has a name equal to the argument.
 * Used only by the patch command, but not all that useful.
 * Enables features like "patch <name-of-other-player> food 999"
 */
object *find_object_name ( char *str );

/*
 * Returns the object which this object marks as being the owner.
 * A id-scheme is used to avoid pointing to objects which have been
 * freed and are now reused.  If this is detected, the owner is
 * set to NULL, and NULL is returned.
 * (This scheme should be changed to a refcount scheme in the future)
 */
object *get_owner ( object *op );

/*
 * Sets the owner of the first object to the second object.
 * Also checkpoints a backup id-scheme which detects freeing (and reusage)
 * of the owner object.
 * See also get_owner() and unset_owner().
 */
void set_owner ( object *op, object *owner );

/*
 * Resets vital variables in an object
 */
void reset_object ( object *op );

/*
 * clear_object() frees everything allocated by an object, and also
 * clears all variables and flags to default settings.
 */
void clear_object ( object *op );

/*
 * copy object first frees everything allocated by the second object,
 * and then copies the contends of the first object into the second
 * object, allocating what needs to be allocated.
 */
void copy_object ( object *op2, object *op );

/*
 * expand_objects() allocates more objects for the list of unused objects.
 * It is called from get_object() if the list unused list is empty.
 */
void expand_objects ( void );

/*
 * get_object() grabs an object from the list of unused objects, makes
 * sure it is initialised, and returns it.
 * If there are no free objects, expand_objects() is called to get more.
 */
object *get_object ( void );

/*
 * If an object with the IS_TURNABLE() flag needs to be turned due
 * to the closest player being on the other side, this function can
 * be called to update the face variable, _and_ how it looks on the map.
 */
void update_turn_face ( object *op );

/*
 * update_object() updates the array which represents the map.
 * It takes into account invisible objects (and represent squares covered
 * by invisible objects by whatever is below them (unless it's another
 * invisible object, etc...))
 * If the object being updated is beneath a player, the look-window
 * of that player is updated (this might be a suboptimal way of
 * updating that window, though, since update_object() is called _often_)
 */
void update_object ( object *op );

/*
 * free_object() frees everything allocated by an object, removes
 * it from the list of used objects, and puts it on the list of
 * free objects.  The IS_FREED() flag is set in the object.
 * The object must have been removed by remove_ob() first for
 * this function to succeed.
 */
void free_object ( object *ob );

/*
 * count_free() returns the number of objects on the list of free objects.
 */
int count_free ( void );

/*
 * count_used() returns the number of objects on the list of used objects.
 */
int count_used ( void );

/*
 * sub_weight() recursively (outwards) subtracts a number from the
 * weight of an object (and what is carried by it's environment(s)).
 */
void sub_weight ( object *op, signed long weight );

/* remove_ob(op):
 *   This function removes the object op from the linked list of objects
 *   which it is currently tied to.  When this function is done, the
 *   object will have no environment.  If the object previously had an
 *   environment, the x and y coordinates will be updated to
 *   the previous environment.
 *   Beware: This function is called from the editor as well!
 */
void remove_ob ( object *op );

/*
 * merge_ob(op,top):
 *
 * This function goes through all objects below and including top, and
 * merges op to the first matching object.
 * If top is NULL, it is calculated.
 * Returns true if it succeded in the merge.
 */
int merge_ob ( object *op, object *top );

/*
 * insert_ob_in_map(op, map):
 * This function inserts the object in the two-way linked list
 * which represents what is on a map.
 * The second argument specifies the map, and the x and y variables
 * in the object about to be inserted specifies the position.
 */
void insert_ob_in_map ( object *op, mapstruct *m );

/*
 * get_split_ob(ob,nr) splits up ob into two parts.  The part which
 * is returned contains nr objects, and the remaining parts contains
 * the rest (or is removed and freed if that number is 0).
 * On failure, NULL is returned, and the reason put into the
 * global static errmsg array.
 */
object *get_split_ob ( object *orig_ob, int nr );

/*
 * decrease_ob_nr(object, number) decreases a specified number from
 * the amount of an object.  If the amount reaches 0, the object
 * is subsequently removed and freed.
 */
void decrease_ob_nr ( object *op, int i );

/*
 * decrease_ob(object) works like decrease_ob_nr(object, 1).
 */
void decrease_ob ( object *op );

/*
 * add_weight(object, weight) adds the specified weight to an object,
 * and also updates how much the environment(s) is/are carrying.
 */
void add_weight ( object *op, signed long weight );

/*
 * insert_ob_in_ob(op,environment):
 *   This function inserts the object op in the linked list
 *   inside the object environment.  If environment is NULL,
 *   the object will be stacked at the map.
 *
 *
 * Eneq(@csd.uu.se): Altered insert_ob_in_ob to make things picked up enter
 * the inventory at the last position or next to other objects of the same
 * type.
 * Frank: Now sorted by type, archetype and magic!
 */
void insert_ob_in_ob ( object *op, object *where );

/*
 * Checks if any objects which has the WALK_ON() (or FLY_ON() if the
 * object is flying) flag set, will be auto-applied by the insertion
 * of the object into the map (applying is instantly done).
 * Any speed-modification due to SLOW_MOVE() of other present objects
 * will affect the speed_left of the object.
 */
void check_walk_on ( object *op );

/*
 * present_arch(arch, map, x, y) searches for any objects with
 * a matching archetype at the given map and coordinates.
 * The first matching object is returned, or NULL if none.
 */
object *present_arch ( archetype *at, mapstruct *m, int x, int y );

/*
 * present(type, map, x, y) searches for any objects with
 * a matching type variable at the given map and coordinates.
 * The first matching object is returned, or NULL if none.
 */
object *present ( unsigned char type, mapstruct *m, int x, int y );

/*
 * present_in_ob(type, object) searches for any objects with
 * a matching type variable in the inventory of the given object.
 * The first matching object is returned, or NULL if none.
 */
object *present_in_ob ( unsigned char type, object *op );

/*
 * present_arch_in_ob(archetype, object) searches for any objects with
 * a matching archetype in the inventory of the given object.
 * The first matching object is returned, or NULL if none.
 */
object *present_arch_in_ob ( archetype *at, object *op );

/*
 * set_cheat(object) sets the cheat flag (WAS_WIZ) in the object and in
 * all it's inventory (recursively).
 * If checksums are used, a player will get set_cheat called for
 * him/her-self and all object carried by a call to this function.
 */
void set_cheat ( object *op );

/*
 * find_free_spot(archetype, map, x, y, start, stop) will search for
 * a spot at the given map and coordinates which will be able to contain
 * the given archetype.  start and stop specifies how many squares
 * to search (see the freearr_x/y[] definition).
 * It returns a random choice among the alternatives found.
 */
int find_free_spot ( archetype *at, mapstruct *m, int x, int y, int
                     start, int stop );

/*
 * find_first_free_spot(archetype, mapstruct, x, y) works like
 * find_free_spot(), but it will search max number of squares.
 * But it will return the first available spot, not a random choice.
 */
int find_first_free_spot ( archetype *at, mapstruct *m, int x, int y );

/*
 * find_dir(map, x, y, exclude) will search some close squares in the
 * given map at the given coordinates for live objects.
 * It will not considered the object given as exlude among possible
 * live objects.
 * It returns the direction toward the first/closest live object if finds
 * any, otherwise 0.
 */
int find_dir ( mapstruct *m, int x, int y, object *exclude );

/*
 * distance(object 1, object 2) will return the square of the
 * distance between the two given objects.
 */
int distance ( object *ob1, object *ob2 );

/*
 * find_dir_2(delta-x,delta-y) will return a direction in which
 * an object which has subtracted the x and y coordinates of another
 * object, needs to travel toward it.
 */
int find_dir_2 ( int x, int y );

/*
 * absdir(int): Returns a number between 1 and 8, which represent
 * the "absolute" direction of a number (it actually takes care of
 * "overflow" in previous calculations of a direction).
 */
int absdir ( int d );

/*
 * dirdiff(dir1, dir2) returns how many 45-degrees differences there is
 * between two directions (which are expected to be absolute (see absdir())
 */
int dirdiff ( int dir1, int dir2 );

/*
 * can_pick(picker, item): finds out if an object is possible to be
 * picked up by the picker.  Returnes 1 on success, otherwise 0.
 */
int can_pick ( object *who, object *item );

/*
 * create clone from object to another
 */
object *ObjectCreateClone ( object *asrc );

/*
 * Returns a newly allocated and initialised and correctly
 * linked player structure.
 */
player *get_player_ob ( void );

void free_player ( player *pl );

/* re-cmp - get regular expression match.
 * Return values: NULL - no match or error in regexp.
 *                pointer to beginning of matching string
 */
char * re_cmp ( char *str, char *regexp );

/*
 * Initialises the hash-table used by the shared string library.
 */
void init_hash_table ( void );

/*
 * Hashing-function used by the shared string library.
 */
int hashstr ( char *str );

/*
 * Allocates and initialises a new shared_string structure, containing
 * the string str.
 */
shared_string * new_shared_string ( char *str );

/*
 * Description:
 *      This will add 'str' to the hash table. If there's no entry for this
 *      string, a copy will be allocated, and a pointer to that is returned.
 * Return values:
 *      - pointer to string identical to str
 */
char * add_string ( char *str );

/*
 * Description:
 *      This will increase the refcount of the string str, which *must*
 *      have been returned from a previous add_string().
 * Return values:
 *      - str
 */
char * add_refcount ( char *str );

/*
 * Description:
 *      This will see if str is in the hash table, and return the address
 *      of that string if it exists.
 * Return values:
 *      - pointer to identical string or NULL
 */
char * find_string ( char *str );

void free_string ( char *str );

/*
 * Description:
 *      The routines will gather statistics if SS_STATISTICS is defined.
 *      A call to this function will cause the statistics to be dumped
 *      into an external string errmsg, which must be large.
 * Return values:
 *      None
 */
void ss_dump_statistics ( void );

/*
 * Description:
 *      If (what & SS_DUMP_TABLE) dump the contents of the hash table to
 *      stderr. If (what & SS_DUMP_TOTALS) return a string which
 *      says how many entries etc. there are in the table.
 * Return values:
 *      - a string or NULL
 */
char * ss_dump_table ( int what );

/*
 * Based on (n+1)^2 = n^2 + 2n + 1
 * given that    1^2 = 1, then
 *        2^2 = 1 + (2 + 1) = 1 + 3 = 4
 *         3^2 = 4 + (4 + 1) = 4 + 5 = 1 + 3 + 5 = 9
 *         4^2 = 9 + (6 + 1) = 9 + 7 = 1 + 3 + 5 + 7 = 16
 *        ...
 * In other words, a square number can be express as the sum of the
 * series n^2 = 1 + 3 + ... + (2n-1)
 */
int isqrt ( int n );

/*
 * A replacement of strdup(), since it's not defined at some
 * unix variants.
 */
char *strdup_local ( char *str );

/*
 * A replacement of strtol() since it's not defined at
 * many unix systems.
 */
long strtol_local ( char *str, char **ptr, int base );

/*
 * Initialise all variables used in the timing routines.
 */
void reset_sleep ( void );

void log_time ( long process_utime );

/*
 * enough_elapsed_time will return true if the time passed since
 * last tick is more than max-time.
 */
int enough_elapsed_time ( void );

/*
 * sleep_delta checks how much time has elapsed since last tick.
 * If it is less than max_time, the remaining time is slept with select().
 */
void sleep_delta ( void );

void set_max_time ( long t );

void time_info ( object *op );

long seconds ( void );

/*
 * Allocate and return the pointer to an empty treasurelist structure.
 */
treasurelist *get_empty_treasurelist ( void );

/*
 * Allocate and return the pointer to an empty treasure structure.
 */
treasure *get_empty_treasure ( void );

/*
 * Reads the lib/treasures file from disk, and parses the contents
 * into an internal treasure structure (very linked lists)
 */
treasure *load_treasure ( FILE *fp );

/*
 * Opens LIBDIR/treasure and reads all treasure-declarations from it.
 * Each treasure is parsed with the help of load_treasure().
 */
void load_treasures ( void );

/*
 * Searches for the given treasurelist in the globally linked list
 * of treasurelists which has been built by load_treasures().
 */
treasurelist *find_treasurelist ( char *name );

/*
 * Searches, with the help of find_treasurelist, for the given
 * treasurelist.  Returns the first of the treasures within
 * the linked list of treasures in the found list.
 * Returns NULL on failure.
 */
treasure *find_treasure ( char *name );

/*
 * Generates the objects specified by the given treasure.
 * It goes recursively through the rest of the linked list.
 * If there is a certain percental chance for a treasure to be generated,
 * this is taken into consideration.
 * The second argument specifies for which object the treasure is
 * being generated.
 * If flag isn't GT_ENVIRONMENT, monster_check_apply() is called.
 * If flag is GT_INVISIBLE, only invisible objects are generated (ie, only
 * abilities.  This is used by summon spells, thus no summoned monsters
 * start with equipment, but only their abilities).
 */
void create_treasure ( treasure *t, object *op, int flag, int difficulty );

/*
 * Based upon the specified difficulty and upon the difftomagic_list array,
 * a random magical bonus is returned.  This is used when determine
 * the magical bonus created on specific maps.
 */
int magic_from_difficulty ( int difficulty );

/*
 * Sets magical bonus in an object, and recalculates the effect on
 * the armour variable, and the effect on speed of armour.
 * This function doesn't work properly, should add use of archetypes
 * to make it truly absolute.
 */
void set_abs_magic ( object *op, int magic );

/*
 * Sets a random magical bonus in the given object based upon
 * the given difficulty, and the given max possible bonus.
 */
void set_magic ( int difficulty, object *op, int max_magic );

/*
 * Randomly adds one magical ability to the given object.
 */
void set_ring_bonus ( object *op, int bonus );

/*
 * get_magic(diff) will return a random number between 0 and 4.
 * diff can be any value above 2.  The higher the diff-variable, the
 * higher is the chance of returning a low number.
 * It is only used in fix_generated_treasure() to set bonuses on
 * rings and amulets.
 * Another scheme is used to calculate the magic of weapons and armours.
 */
int get_magic ( int diff );

/*
 * generate_treasure() creates an object based upon the given list of
 * objectnames (or new objectlists) and the given difficulty.
 * The lists are specified in the include/treasure.h file.
 * NULL is returned on failure.
 */
object *generate_treasure ( int list, int difficulty );

/*
 * fix_generated_item():  This is called after an item is generated, in
 * order to set it up right.  This produced magical bonuses, puts spells
 * into scrolls/books/wands, makes it unidentified, hides the value, etc.
 */
void fix_generated_item ( object *op, int difficulty, int max_magic );

/*
 * Used in artifact generation.  The bonuses of the first object
 * is modified by the bonuses of the second object.
 */
void add_abilities ( object *op, object *change );

/*
 * Gives some items special abilities, powers and curses
 */
void generate_artifact ( object *op );

/*
 * If the artifact-lists haven't been initialised already, a call
 * to this function will result in a call to read_artifacts()
 */
void init_artifacts ( void );

/*
 * For debugging purposes.  Dumps all tables.
 */
void dump_artifacts ( void );

/*
 * Builds up the lists of artifacts from the file in the libdir.
 */
void read_artifacts ( void );

/*
 * Converts between Fontindex and XChar2b types.
 */
XChar2b fontindex_to_XChar2b ( Fontindex s );

/*
 * read_bmaps(): When bitmaps are used instead of fonts, this function
 * does the actual reading of all the bitmap-files, and sets up the
 * player->bitmaps array.  It assumes the bitmap directory and the
 * bmaps file are found in the LIBDIR directory.
 */
void read_bmaps ( player *pl );

/*
 * This function adds the path to the fontpath of the given display.
 * It's mostly copied from the X11R5 distribution.
 */
void set_font_path ( Display *dpy, char *path );

/*
 * Checks if "crossfire" is present somewhere in the fontpath of
 * the given display.
 */
int check_font_path ( Display *dpy );

/*
 * Uses check_font_path() and set_font_path() to check and, if needed
 * fix the fontpath for a player.
 * If it fails, it sets the "use_pixmaps" flag in the player structure,
 * which will prompt the read_bmaps() function at a later time.
 */
int fixfontpath ( player *pl );

/*
 * allocate_colors() tries to get enough colors for the game-window.
 * If it fails, it tries to use a private colormap.
 * If that also fails, it switches mode to black/white.
 */
void allocate_colors ( player *p, Window w );

#endif /* __STDC__ */
#endif /* __CEXTRACT__ */